package com.wc.alorithm_blue_bridge._DFS.Q5315;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.*;

/**
 * @Author congege
 * @Description
 * @Date Created in 2023/11/28-11:46
 */
public class Main2 {
    static int[] array;
    static boolean[] visNum;

    static int n;
    static char[] operators = new char[]{'*', '+', '-', '/'};
    static char[] calOperators;
    static int[] calNums;
    static ArrayList<String> ansStr = new ArrayList<>();
    static String ans = "NO";
    static FastReader sc = new FastReader();
    static PrintWriter out = new PrintWriter(System.out);

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        String[] arrStr = new String[n];
        array = new int[n];
        visNum = new boolean[n];
        calOperators = new char[n];
        calNums = new int[n];
        for (int i = 0; i < n; i++) {
            arrStr[i] = sc.next();
        }
        Arrays.sort(arrStr);
        for (int i = 0; i < n; i++) {
            array[i] = Integer.parseInt(arrStr[i]);
        }

        for (int i = 0; i < n; i++) {
            visNum[i] = true;
            calNums[0] = array[i];
            if (dfsNum(1)) {
                break;
            }
            visNum[i] = false;
        }

        System.out.println(ans);
    }

    public static boolean dfsNum(int floor) {
        if (floor == n) {
            return dfsOperator(1);
        }
        for (int i = 0; i < n; i++) {
            if (!visNum[i]) {
                visNum[i] = true;
                calNums[floor] = array[i];
                if (dfsNum(floor + 1)) {
                    return true;
                }
                visNum[i] = false;
            }
        }
        return false;
    }

    static String operate;

    public static boolean dfsOperator(int floor) {
        if (floor == n) {
            operate = combine();

            if (isTwentyFour(operate)) {
                String tmp = "YES\n" + operate + "=24";
                if (ans.equals("NO") || ans.compareTo(tmp) > 0) {
                    ans = tmp;
                }
                return true;
            }
            return false;
        }
        for (char operator : operators) {
            calOperators[floor] = operator;
            if (dfsOperator(floor + 1)) {
                return true;
            }
        }
        return false;
    }

    public static String combine() {
        StringBuffer ans = new StringBuffer();
        ans.append(calNums[0]);
        for (int i = 1; i < n; i++) {
            ans.append(calOperators[i]);
            ans.append(calNums[i]);
        }
        return ans.toString();
    }
//    static public boolean cal(StringBuffer operate, char operator, int numIdx, int floor) {
//        operate.append(operator);
//        operate.append(array[numIdx]);
//        return dfs(operate, floor + 1);
//    }


    public static boolean isTwentyFour(String s) {
        char[] chs = s.toCharArray();
        double preNum = 0;
        Stack<Double> nums = new Stack<>();
        Stack<Character> operators = new Stack<>();
        for (int i = 0; i < chs.length; i++) {
            if (chs[i] >= '0' && chs[i] <= '9') {
                preNum = preNum * 10 + chs[i] - '0';
            } else {
                if (preNum != 0) {
                    nums.push(preNum);
                }
                preNum = 0;
                operators.push(chs[i]);
                if (chs[i] == '*' || chs[i] == '/') {
                    i++;
                    while (i < chs.length && chs[i] >= '0' && chs[i] <= '9') {
                        preNum = preNum * 10 + chs[i] - '0';
                        i++;
                    }
                    // 恢复一下,抵消上面的i++
                    i--;
                    nums.push(calculate(nums.pop(), preNum, operators.pop()));
                }
                preNum = 0;
            }
        }
        if (preNum != 0) {
            nums.push(preNum);
        }
        while (nums.size() != 1) {
            double b = nums.pop();
            double a = nums.pop();
            char operator = operators.pop();
            nums.push(calculate(a, b, operator));
        }

        return nums.pop() == 24;
    }

    public static double calculate(double a, double b, char operator) {
        switch (operator) {
            case '+':
                return a + b;
            case '-':
                return a - b;
            case '*':
                return a * b;
            case '/':
                // 要影响他们
                if (a % b != 0) {
                    return -500000;
                }
                return a / b;
        }
        return 0;
    }
}

class FastReader {
    StringTokenizer st;
    BufferedReader br;

    FastReader() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
        while (st == null || !st.hasMoreElements()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    String nextLine() {
        String s = "";
        try {
            s = br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return s;
    }

    long nextLong() {
        return Long.parseLong(next());
    }

    double nextDouble() {
        return Double.parseDouble(next());
    }

    // 是否由下一个
    boolean hasNext() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                String line = br.readLine();
                if (line == null)
                    return false;
                st = new StringTokenizer(line);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return true;
    }
}